/**
 * 数据库工具类测试文件
 * 验证改造后的数据库工具类是否符合HTTP API数据格式规范
 */

import database, { DB_STATUS_CODES } from './database.js'

/**
 * 测试数据库操作的统一响应格式
 */
class DatabaseTest {
  constructor() {
    this.testResults = []
  }

  /**
   * 记录测试结果
   */
  logTest(testName, result, expected) {
    const passed = this.validateResponse(result, expected)
    this.testResults.push({
      testName,
      passed,
      result,
      expected
    })
    
    console.log(`${passed ? '✅' : '❌'} ${testName}:`, result)
  }

  /**
   * 验证响应格式是否符合规范
   */
  validateResponse(response, expectedCode = DB_STATUS_CODES.SUCCESS) {
    // 检查基本结构
    if (!response || typeof response !== 'object') {
      return false
    }

    // 检查必需字段
    if (typeof response.code !== 'number' || 
        typeof response.message !== 'string' || 
        !response.hasOwnProperty('data')) {
      return false
    }

    // 检查状态码
    if (response.code !== expectedCode) {
      return false
    }

    return true
  }

  /**
   * 验证分页响应格式
   */
  validatePaginationResponse(response) {
    if (!this.validateResponse(response)) {
      return false
    }

    const { data } = response
    if (!data || typeof data !== 'object') {
      return false
    }

    // 检查分页字段
    if (!Array.isArray(data.list) ||
        typeof data.page !== 'number' ||
        typeof data.pageSize !== 'number' ||
        typeof data.total !== 'number') {
      return false
    }

    return true
  }

  /**
   * 运行所有测试
   */
  async runAllTests() {
    console.log('🚀 开始数据库API格式规范测试...')
    
    try {
      // 测试数据库初始化
      await this.testInit()
      
      // 测试参数验证
      await this.testParameterValidation()
      
      // 测试CRUD操作
      await this.testCRUDOperations()
      
      // 测试分页查询
      await this.testPagination()
      
      // 测试错误处理
      await this.testErrorHandling()
      
      // 输出测试结果
      this.printTestResults()
      
    } catch (error) {
      console.error('测试过程中发生错误:', error)
    }
  }

  /**
   * 测试数据库初始化
   */
  async testInit() {
    console.log('\n📋 测试数据库初始化...')
    
    const result = await database.init()
    this.logTest('数据库初始化', result, DB_STATUS_CODES.SUCCESS)
  }

  /**
   * 测试参数验证
   */
  async testParameterValidation() {
    console.log('\n📋 测试参数验证...')
    
    // 测试空表名
    const emptyTableResult = await database.query('')
    this.logTest('空SQL查询', emptyTableResult, DB_STATUS_CODES.PARAM_ERROR)
    
    // 测试空数据插入
    const emptyDataResult = await database.insert('users', {})
    this.logTest('空数据插入', emptyDataResult, DB_STATUS_CODES.PARAM_ERROR)
    
    // 测试无效分页参数
    const invalidPageResult = await database.paginate('users', { page: 0 })
    this.logTest('无效分页参数', invalidPageResult, DB_STATUS_CODES.PARAM_ERROR)
  }

  /**
   * 测试CRUD操作
   */
  async testCRUDOperations() {
    console.log('\n📋 测试CRUD操作...')
    
    // 测试插入
    const insertResult = await database.insert('users', {
      id: 'test_user_1',
      username: 'testuser',
      email: 'test@example.com',
      nickname: '测试用户'
    })
    this.logTest('插入用户', insertResult, DB_STATUS_CODES.SUCCESS)
    
    // 测试查询
    const queryResult = await database.query(
      'SELECT * FROM users WHERE username = ?', 
      ['testuser']
    )
    this.logTest('查询用户', queryResult, DB_STATUS_CODES.SUCCESS)
    
    // 测试更新
    const updateResult = await database.update(
      'users',
      { nickname: '更新的测试用户' },
      'username = ?',
      ['testuser']
    )
    this.logTest('更新用户', updateResult, DB_STATUS_CODES.SUCCESS)
    
    // 测试删除
    const deleteResult = await database.delete(
      'users',
      'username = ?',
      ['testuser']
    )
    this.logTest('删除用户', deleteResult, DB_STATUS_CODES.SUCCESS)
  }

  /**
   * 测试分页查询
   */
  async testPagination() {
    console.log('\n📋 测试分页查询...')
    
    // 插入测试数据
    for (let i = 1; i <= 25; i++) {
      await database.insert('users', {
        id: `test_user_${i}`,
        username: `user${i}`,
        email: `user${i}@example.com`,
        nickname: `用户${i}`
      })
    }
    
    // 测试分页查询
    const paginationResult = await database.paginate('users', {
      page: 1,
      pageSize: 10
    })
    
    const isValidPagination = this.validatePaginationResponse(paginationResult)
    this.logTest('分页查询格式验证', { 
      code: isValidPagination ? 0 : 1001, 
      message: isValidPagination ? '分页格式正确' : '分页格式错误',
      data: paginationResult.data 
    }, DB_STATUS_CODES.SUCCESS)
    
    // 验证分页数据结构
    if (paginationResult.code === DB_STATUS_CODES.SUCCESS) {
      const { data } = paginationResult
      console.log('分页数据结构:', {
        listLength: data.list.length,
        page: data.page,
        pageSize: data.pageSize,
        total: data.total
      })
    }
  }

  /**
   * 测试错误处理
   */
  async testErrorHandling() {
    console.log('\n📋 测试错误处理...')
    
    // 测试不存在的表
    const invalidTableResult = await database.query('SELECT * FROM non_existent_table')
    this.logTest('查询不存在的表', invalidTableResult, DB_STATUS_CODES.SYSTEM_ERROR)
    
    // 测试更新不存在的记录
    const updateNonExistentResult = await database.update(
      'users',
      { nickname: '不存在的用户' },
      'id = ?',
      ['non_existent_id']
    )
    this.logTest('更新不存在的记录', updateNonExistentResult, DB_STATUS_CODES.NOT_FOUND)
  }

  /**
   * 打印测试结果
   */
  printTestResults() {
    console.log('\n📊 测试结果汇总:')
    
    const passedTests = this.testResults.filter(test => test.passed)
    const failedTests = this.testResults.filter(test => !test.passed)
    
    console.log(`✅ 通过: ${passedTests.length}/${this.testResults.length}`)
    console.log(`❌ 失败: ${failedTests.length}/${this.testResults.length}`)
    
    if (failedTests.length > 0) {
      console.log('\n失败的测试:')
      failedTests.forEach(test => {
        console.log(`- ${test.testName}:`, test.result)
      })
    }
    
    console.log('\n🎉 数据库API格式规范测试完成!')
  }
}

// 导出测试类
export default DatabaseTest

// 如果直接运行此文件，执行测试
if (typeof window !== 'undefined' && window.location) {
  // 在浏览器环境中运行
  const test = new DatabaseTest()
  test.runAllTests()
} else if (typeof process !== 'undefined' && process.env) {
  // 在Node.js环境中运行
  const test = new DatabaseTest()
  test.runAllTests()
}